CSM-424- Evolutionary Complexity: Investigations into Software Flexibility

Flexibility has been hailed as a desirable quality since the earliest days of software engineering. Classic and modern literature suggest that particular programming paradigms, architectural styles and design patterns are more “flexible” than others but stop short of suggesting objective criteria for measuring such claims. We suggest that flexibility can be measured by applying notions of measurement from computational complexity to the software evolution process. We define evolution complexity (EC) metrics, and demonstrate that— (a) EC can be used to establish informal claims on software flexibility; (b) EC can be constant ����or linear� in the size of the change; (c) EC can be used to choose the most flexible software design policy. We describe a small-scale experiment designed to test these claims

On the Definition of Architecture, Design and Implementation

The terms architecture, design, and implementation are typically used informally in partitioning software specifications into three coarse strata of abstraction. But these strata are not well-defined in either research or practice and often overlap causing confusion and needless discussion. To remedy this problem we formally define two criteria: the Intension and the Locality Criteria, and show that the intuitive discrimination between the three terms architecture, design, and implementation is qualitative and not merely quantitative. We demonstrate that architectural styles are intensional and non-local; that design patterns are intensional and local; and that implementations are extensional and loca

CSM-473: Design Mining in LePUS3/Class-Z:Search Space and Abstraction/Concretization Operators

LePUS3 is a specification and modelling language designed to capture the building blocks of O-O design at different levels of abstraction. We identify the set of LePUS3 specifications that agree with (are satisfied by) an O-O program (represented by a LePUS3 design model) as the search space for a host of design mining problems such as: reverse engineering, design recovery, design pattern detection, design pattern discovery. We show that this search space is a mathematical lattice (with relation to a particular program) and we demonstrate how it can be traversed using a set of abstraction and concretization operators

Automated Verification of Design Patterns with LePUS3

Specification and [visual] modelling languages are expected to combine strong abstraction mechanisms with rigour, scalability, and parsimony. LePUS3 is a visual, object-oriented design description language axiomatized in a decidable subset of the first-order predicate logic. We demonstrate how LePUS3 is used to formally specify a structural design pattern and prove (‗verify‘) whether any JavaTM 1.4 program satisfies that specification. We also show how LePUS3 specifications (charts) are composed and how they are verified fully automatically in the Two-Tier Programming Toolkit

CSM-472: The 'Gang of Four' Companion

This document demonstrates how the informal specifications of the design patterns the 'Gang of Four' seminal catalogue [Gamma et al 1995] can be specified formally using the LePUS3 and Class-Z object-oriented Architecture Description Languages

CSM-474: LePUS3 and Class-Z Reference Manual

This document formally defines the elements in the syntax and the semantics of LePUS3 and the Class-Z specification languages. It was designed to satisfy the rigid requirements of mathematical logic, and it is therefore unsuitable for learning LePUS3 and Class-Z. More suitable for this purpose will be the book "Object-Oriented Modelling" [Eden under preparation]. A legend offering a key to the language's symbols is also available

LePUS3: An Object-Oriented Design Description Language

LePUS3 [1] (lepus.org.uk) is a logic, visual, object-oriented Design Description Language: a formal specification language designed to capture and convey the building-blocks of object-oriented design. LePUS3 minimal vocabulary constitutes of abstraction mechanisms that can specify effectively and precisely design patterns and the design of JavaTM (C++, Smalltalk, etc.) programs at any level of abstraction